class PoolingVsNoPoolingTest {  
  
    private final Logger log = LoggerFactory.getLogger(PoolingVsNoPoolingTest.class);  
  
    private static final int COUNT = 1000;  
  
    private static MySQLContainer<?> container;  
  
    @BeforeAll  
    static void beforeAll() throws SQLException {  
        // TestContainer로 임시 MySQL을 실행한다.  
        container = new MySQLContainer<>(DockerImageName.parse("mysql:8.0.30"))  
                .withDatabaseName("test");  
        container.start();  
  
        final var dataSource = createMysqlDataSource();  
  
        // 테스트에 사용할 users 테이블을 생성하고 데이터를 추가한다.  
        try (Connection conn = dataSource.getConnection()) {  
            conn.setAutoCommit(true);  
            try (Statement stmt = conn.createStatement()) {  
                stmt.execute("DROP TABLE IF EXISTS users;");  
                stmt.execute("CREATE TABLE IF NOT EXISTS users (id INT AUTO_INCREMENT PRIMARY KEY, email VARCHAR(100) NOT NULL) ENGINE=INNODB;");  
                stmt.executeUpdate("INSERT INTO users (email) VALUES ('hkkang@woowahan.com')");  
                conn.setAutoCommit(false);  
            }  
        }  
    }  
  
    @AfterAll  
    static void afterAll() {  
        container.stop();  
    }  
  
    @Test  
    void noPoling() throws SQLException {  
        final var dataSource = createMysqlDataSource();  
  
        long start = ClockSource.currentTime();  
        connect(dataSource);  
        long end = ClockSource.currentTime();  
  
        // 테스트 결과를 확인한다.  
        log.info("Elapsed runtime: {}", ClockSource.elapsedDisplayString(start, end));  
    }  
  
    @Test  
    void pooling() throws SQLException {  
        final var config = new HikariConfig();  
        config.setJdbcUrl(container.getJdbcUrl());  
        config.setUsername(container.getUsername());  
        config.setPassword(container.getPassword());  
        config.setMinimumIdle(1);  
        config.setMaximumPoolSize(1);  
        config.setConnectionTimeout(1000);  
        config.setAutoCommit(false);  
        config.setReadOnly(false);  
        final var hikariDataSource = new HikariDataSource(config);  
  
        long start = ClockSource.currentTime();  
        connect(hikariDataSource);  
        long end = ClockSource.currentTime();  
  
        // 테스트 결과를 확인한다.  
        log.info("Elapsed runtime: {}", ClockSource.elapsedDisplayString(start, end));  
    }  
  
    private static void connect(DataSource dataSource) throws SQLException {  
        // COUNT만큼 DB 연결을 수행한다.  
        for (int i = 0; i < COUNT; i++) {  
            try (Connection connection = dataSource.getConnection()) {  
                try (Statement stmt = connection.createStatement();  
                     ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {  
                    if (rs.next()) {  
                        rs.getString(1).hashCode();  
                    }  
                }  
            }  
        }  
    }  
  
    private static MysqlDataSource createMysqlDataSource() throws SQLException {  
        final var dataSource = new MysqlDataSource();  
        dataSource.setUrl(container.getJdbcUrl());  
        dataSource.setUser(container.getUsername());  
        dataSource.setPassword(container.getPassword());  
        dataSource.setConnectTimeout(1000);  
        return dataSource;  
    }  
}

class Stage0Test {  
  
    private static final String H2_URL = "jdbc:h2:./test";  
    private static final String USER = "sa";  
    private static final String PASSWORD = "";  
  
    @Test  
    void driverManager() throws SQLException {  
        // Class.forName("org.h2.Driver");
        
        try (final Connection connection = DriverManager.getConnection(H2_URL, USER, PASSWORD)) {  
            assertThat(connection.isValid(1)).isTrue();  
        }  
    }  
}

	...
	@Test  
    void dataSource() throws SQLException {  
        final JdbcDataSource dataSource = new JdbcDataSource();  
        dataSource.setURL(H2_URL);  
        dataSource.setUser(USER);  
        dataSource.setPassword(PASSWORD);  
  
        try (final var connection = dataSource.getConnection()) {  
            assertThat(connection.isValid(1)).isTrue();  
        }  
    }  
}

class Stage1Test {  
  
    private static final String H2_URL = "jdbc:h2:./test;DB_CLOSE_DELAY=-1";  
    private static final String USER = "sa";  
    private static final String PASSWORD = "";  
  
    @Test  
    void testJdbcConnectionPool() throws SQLException {  
        final JdbcConnectionPool jdbcConnectionPool = JdbcConnectionPool.create(H2_URL, USER, PASSWORD);  
  
        assertThat(jdbcConnectionPool.getActiveConnections()).isZero();  
        try (final var connection = jdbcConnectionPool.getConnection()) {  
            assertThat(connection.isValid(1)).isTrue();  
            assertThat(jdbcConnectionPool.getActiveConnections()).isEqualTo(1);  
        }  
        assertThat(jdbcConnectionPool.getActiveConnections()).isZero();  
  
        jdbcConnectionPool.dispose();  
    }  
}

	@Test  
    void testHikariCP() {  
        final var hikariConfig = new HikariConfig();  
        hikariConfig.setJdbcUrl(H2_URL);  
        hikariConfig.setUsername(USER);  
        hikariConfig.setPassword(PASSWORD);  
        hikariConfig.setMaximumPoolSize(5);  
        hikariConfig.addDataSourceProperty("cachePrepStmts", "true");  
        hikariConfig.addDataSourceProperty("prepStmtCacheSize", "250");  
        hikariConfig.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");  
  
        final var dataSource = new HikariDataSource(hikariConfig);  
        final var properties = dataSource.getDataSourceProperties();  
  
        assertThat(dataSource.getMaximumPoolSize()).isEqualTo(5);  
        assertThat(properties.getProperty("cachePrepStmts")).isEqualTo("true"); assertThat(properties.getProperty("prepStmtCacheSize")).isEqualTo("250");  assertThat(properties.getProperty("prepStmtCacheSqlLimit")).isEqualTo("2048");  
  
        dataSource.close();  
    }  
}

@Configuration  
public class DataSourceConfig {  
  
    public static final int MAXIMUM_POOL_SIZE = 5;  
    private static final String H2_URL = "jdbc:h2:./test;DB_CLOSE_DELAY=-1";  
    private static final String USER = "sa";  
    private static final String PASSWORD = "";  
  
  
    @Bean  
    public DataSource hikariDataSource() {  
        final var hikariConfig = new HikariConfig();  
        hikariConfig.setPoolName("gugu");  
        hikariConfig.setJdbcUrl(H2_URL);  
        hikariConfig.setUsername(USER);  
        hikariConfig.setPassword(PASSWORD);  
        hikariConfig.setMaximumPoolSize(MAXIMUM_POOL_SIZE);  
        hikariConfig.setConnectionTestQuery("VALUES 1");  
        hikariConfig.addDataSourceProperty("cachePrepStmts", "true");  
        hikariConfig.addDataSourceProperty("prepStmtCacheSize", "250");  
        hikariConfig.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");  
  
        return new HikariDataSource(hikariConfig);  
    }  
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)  
class Stage2Test {  
  
    private static final Logger log = LoggerFactory.getLogger(Stage2Test.class);  
  
    @Autowired  
    private DataSource dataSource;  
  
    @Test  
    void test() throws InterruptedException {  
        final var hikariDataSource = (HikariDataSource) dataSource;  
        final var hikariPool = getPool((HikariDataSource) dataSource);  
  
        // 설정한 커넥션 풀 최대값보다 더 많은 스레드를 생성해서 동시에 디비에 접근을 시도하면 어떻게 될까?  
        final var threads = new Thread[20];  
        for (int i = 0; i < threads.length; i++) {  
            threads[i] = new Thread(getConnection());  
        }  
  
        for (final var thread : threads) {  
            thread.start();  
        }  
  
        for (final var thread : threads) {  
            thread.join();  
        }  
  
        // 동시에 많은 요청이 몰려도 최대 풀 사이즈를 유지한다.  
        assertThat(hikariPool.getTotalConnections()).isEqualTo(DataSourceConfig.MAXIMUM_POOL_SIZE);  
  
        // DataSourceConfig 클래스에서 직접 생성한 커넥션 풀.  
        assertThat(hikariDataSource.getPoolName()).isEqualTo("gugu");  
    }  
  
    private Runnable getConnection() {  
        return () -> {  
            try {  
                log.info("Before acquire ");  
                try (Connection ignored = dataSource.getConnection()) {  
                    log.info("After acquire ");  
                    quietlySleep(500);  
                }  
            } catch (Exception e) {  
            }  
        };  
    }  
    
    public static HikariPool getPool(final HikariDataSource hikariDataSource)  
    {  
        try {  
            Field field = hikariDataSource.getClass().getDeclaredField("pool");  
            field.setAccessible(true);  
            return (HikariPool) field.get(hikariDataSource);  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
}